home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 20 / Cream of the Crop 20 (Terry Blount) (1996).iso / program / recio214.zip / RECIO.C < prev    next >
C/C++ Source or Header  |  1996-06-14  |  15KB  |  412 lines
  1. /*****************************************************************************
  2.    MODULE: recio.c
  3.   PURPOSE: record input/output functions
  4. COPYRIGHT: (C) 1994-1996, William Pierpoint
  5.  COMPILER: Borland C Version 3.1
  6.        OS: MSDOS Version 6.2
  7.   VERSION: 2.14
  8.   RELEASE: June 14, 1996
  9. *****************************************************************************/
  10.  
  11. #include <ctype.h>
  12. #include <errno.h>
  13. #include <float.h>
  14. #include <limits.h>
  15. #include <stdio.h>
  16. #include <stdlib.h>
  17. #include <string.h>
  18.  
  19. #include "recio.h"
  20.  
  21. #define rcol(rp)         ((rp)->r_colno)
  22. #define rflags(rp)       ((rp)->r_flags)
  23. #define rfd(rp)          ((rp)->r_fd)
  24. #define rfp(rp)          ((rp)->r_fp)
  25. #define rreclen(rp)      ((rp)->r_reclen)
  26. #define rrecsiz(rp)      ((rp)->r_recsiz)
  27. #define rfldsiz(rp)      ((rp)->r_fldsiz)
  28. #define rfldch(rp)       ((rp)->r_fldch)
  29. #define rtxtch(rp)       ((rp)->r_txtch)
  30. #define rtmfmt(rp)       ((rp)->r_tmfmt)
  31.  
  32. /* private module variables */
  33. static REC *_RECS = NULL;              /* ptr to array of RECs */
  34. static char _tmfmt[] = "%m/%d/%y";     /* default time format string */
  35.  
  36. static REC rin  = { 1,      0,    stdin,  "stdin",     0L,
  37.                     0,      0,        0,        0,   NULL, 
  38.                     0,   NULL, RECFLDCH, RECTXTCH,  _tmfmt, RECIN };
  39.  
  40. static REC rout = { 2, _R_WRT,   stdout, "stdout",     0L, 
  41.                     0,      0,        0,        0,   NULL, 
  42.                     0,   NULL, RECFLDCH, RECTXTCH, _tmfmt, RECOUT };
  43.  
  44. static REC rerr = { 3, _R_WRT,   stderr, "stderr",     0L, 
  45.                     0,      0,        0,        0,   NULL, 
  46.                     0,   NULL, RECFLDCH, RECTXTCH, _tmfmt, RECERR };
  47.  
  48. #if defined (__MSDOS__) || (MSDOS)
  49. static REC rprn = { 4, _R_WRT,   stdprn, "stdprn",     0L, 
  50.                     0,      0,        0,        0,   NULL, 
  51.                     0,   NULL, RECFLDCH, RECTXTCH, _tmfmt, RECPRN };
  52. #define NREC      4          /* number of static record streams */
  53. #else
  54. #define NREC      3
  55. #endif
  56.  
  57. #define ROPEN_MIN NREC       /* reserved for recin, etc */
  58. #define ROPEN     max(ROPEN_MAX, ROPEN_MIN)
  59.  
  60. /* public variables */
  61. REC *recin = &rin;
  62. REC *recout = &rout;
  63. REC *recerr = &rerr;
  64. #if defined (__MSDOS__) || (MSDOS)
  65. REC *recprn = &rprn;
  66. #endif
  67.  
  68. /* friend variables */
  69. char _r_nsbuf[NSBUFSIZ];     /* buffer for numeric to string conversions */
  70. void (*_r_errfn)(REC *);     /* pointer to error message function */
  71.  
  72. /* Support functions */
  73. /****************************************************************************/
  74. static void                  /* returns nothing                             */
  75.     _rexit(                  /* at program exit, clean up                   */
  76.         void)                /* no arguments                                */
  77. /****************************************************************************/
  78. {
  79.     /* free recin buffers */
  80.     free(rflds(recin));
  81.     free(rrecs(recin));
  82.     rflds(recin) = NULL;
  83.     rfldsiz(recin) = 0;
  84.     rrecs(recin) = NULL;
  85.     rrecsiz(recin) = 0;
  86.     rreclen(recin) = 0;
  87.  
  88.     /* ensure all record streams closed */
  89.     rcloseall();
  90. }
  91.  
  92. /****************************************************************************/
  93. void                         /* return error number (0=no error)            */
  94.     _rsetexitfn(             /* register _rexit function with atexit()      */
  95.         REC *rp)             /* record pointer                              */
  96. /****************************************************************************/
  97. {
  98.     static int once=0;       /* register exit fn only once */
  99.  
  100.     if (!once) {
  101.  
  102.         /* execute this path at most one time */
  103.         once++;
  104.  
  105.         /* if atexit() fails to register _rexit() function */
  106.         if (atexit(_rexit)) {
  107.  
  108.            /* register warning */
  109.            rsetwarn(rp, R_WNOREG);
  110.         }
  111.     }
  112. } 
  113.  
  114. /****************************************************************************/
  115. int                          /* return error number (0=no error)            */
  116.     _rmoderror(              /* check for mode error                        */
  117.         REC *rp,             /* record pointer                              */
  118.         int mode)            /* mode (0=read; !0=write/append)              */
  119. /****************************************************************************/
  120. {
  121.     int errnum=0;            /* error number (0=mode ok, !0=invalid mode) */
  122.     unsigned smode;          /* stream mode */
  123.  
  124.     /* if stream _R_WRT flag does not match mode */
  125.     smode = rflags(rp) & _R_WRT;
  126.     if ((mode && !smode) || (!mode && smode)) {
  127.         errnum = rseterr(rp, R_EINVMOD);
  128.     }
  129.     return errnum;
  130. }
  131.  
  132. /****************************************************************************/
  133. int                          /* return !0 if ready; 0 if in error state     */
  134.     _risready(               /* see if record stream is ready               */
  135.         REC *rp,             /* record pointer                              */
  136.         int mode)            /* mode (0=read; !0=write/append)              */
  137. /****************************************************************************/
  138. {
  139.     int errnum=0;            /* error number */
  140.  
  141.     /* test for valid record pointer */
  142.     if (!risvalid(rp)) {
  143.         errnum = rseterr(NULL, EINVAL);
  144.         goto done;
  145.     }
  146.     
  147.     /* check mode */
  148.     errnum = _rmoderror(rp, mode);
  149.     if (errnum) goto done;
  150.  
  151.     /* if record 0 and write mode, set record number to 1 */
  152.     if (!rrecno(rp) && mode) rrecno(rp)++;
  153.  
  154.     /* test for any previous error */
  155.     errnum = rerror(rp);
  156.  
  157. done:
  158.     return (!(errnum));
  159. }
  160.  
  161. /****************************************************************************/
  162. static void                  /* returns nothing                             */
  163.     _rfree(                  /* free the memory allocated to a record       */
  164.         REC *rp)             /* record pointer                              */
  165. /****************************************************************************/
  166. {
  167.     if (risvalid(rp)) {
  168.         free(rflds(rp));
  169.         free(rrecs(rp));
  170.         if (rfp(rp)) fclose(rfp(rp));
  171.         memset(rp, 0, sizeof(REC));
  172.     }
  173. }
  174.  
  175. /* User functions */
  176. /****************************************************************************/
  177. REC *                        /* return record pointer                       */
  178.     ropen(                   /* open a record stream for reading            */
  179.         const char *fname,   /* name of file to open                        */
  180.         const char *mode)    /* type of mode used to open file              */
  181. /****************************************************************************/
  182. {
  183.     REC *rp = _RECS;         /* record pointer */
  184.     int  i;                  /* count of REC structures */
  185.     int  ch;                 /* first character of mode */
  186.     
  187.     errno = 0;
  188.  
  189.     /* only modes currently supported are "r", "w", and "a" */
  190.     ch = tolower(*mode);
  191.     if (!(ch=='r' || ch=='w' || ch=='a')) {
  192.         rp = NULL;
  193.         rseterr(NULL, EINVAL);
  194.         goto done;
  195.     }
  196.  
  197.     /* allocate memory for array of REC structures */
  198.     if (!rp) {
  199.         do {
  200.             /* note: no memory allocation needed for recin, etc */
  201.             rp = _RECS = (REC *) calloc(ROPEN-NREC, sizeof(REC));
  202.             if (!rp) {
  203.                 if (rseterr(NULL, ENOMEM)) goto done;
  204.             }
  205.         } while (!rp);
  206.     }
  207.  
  208.     /* search thru REC structures until empty position found */
  209.     for (i=NREC+1; i <= ROPEN; i++, rp++) {
  210.         if (!rfd(rp)) {
  211.             rfd(rp) = i;
  212.             break;
  213.         }
  214.     }
  215.     /* error if out of positions */
  216.     if (i > ROPEN) {
  217.         rp = NULL;
  218.         rseterr(NULL, EMFILE);
  219.         goto done;
  220.     }
  221.  
  222.     /* open file */
  223.     rfp(rp) = fopen(fname, mode);
  224.     if (!rfp(rp)) {
  225.         rclose(rp);
  226.         rp = NULL;
  227.         /* if error other than path/file not found */
  228.         if (errno != ENOENT) {
  229.             rseterr(NULL, errno);
  230.         }
  231.         goto done;
  232.     }
  233.  
  234.     /*